#ifndef _SERVER_H__
#define _SERVER_H__

#include "db.hpp"
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"

class gobang_server{
    private:
        void http_resp(wsserver_t::connection_ptr& conn, bool result, websocketpp::http::status_code::value code, const std::string& reason)
        {
            Json::Value resp_json;
            resp_json["result"] = result;
            resp_json["reason"] = reason;
            std::string resp_body;
            json_util::serialize(resp_json, resp_body);
            conn->set_status(code);
            conn->set_body(resp_body);
            conn->append_header("Content-Type", "application/json");
            return;
        }
        void regist(wsserver_t::connection_ptr& conn)
        {
            //用户注册功能请求的处理
            //1.获取请求正文
            std::string req_body = conn->get_request_body();
            //2.对正文进行反序列化，得到用户名和密码
            Json::Value login_info;
            bool ret = json_util::unserialize(req_body, login_info);
            if(ret == false)
            {
                DBG_LOG("反序列化注册信息失败");
                http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
                return;
            }
            //3.进行数据库的用户新增操作
            if(login_info["username"].isNull() || login_info["password"].isNull())
            {
                DBG_LOG("用户名密码不完整");
                http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名或密码");
                return;                
            }
            ret = _ut.insert(login_info);
            if(ret == false)
            {
                DBG_LOG("向数据库插入数据失败");
                http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户已注册");
                return;
            }
            //如果成功了。则返回200
            http_resp(conn, true, websocketpp::http::status_code::ok, "注册成功");
            return;
        }
        void login(wsserver_t::connection_ptr& conn)
        {
            //用户登录功能请求的处理
            //1. 获取请求正⽂，并进⾏json反序列化，得到⽤⼾名和密码
            std::string req_body = conn->get_request_body();
            Json::Value login_info;
            bool ret = json_util::unserialize(req_body, login_info);
            if (ret == false) 
            {
                DBG_LOG("反序列化登录信息失败");
                return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正⽂格式错误");
            }
            //2. 校验正⽂完整性，进⾏数据库的⽤⼾信息验证
            if (login_info["username"].isNull() || login_info["password"].isNull()) 
            {
                DBG_LOG("⽤⼾名密码不完整");
                return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输⼊⽤⼾名/密码");
            }
            ret = _ut.login(login_info);
            if (ret == false) 
            {
                // 1. 如果验证失败，则返回400
                DBG_LOG("⽤⼾名密码错误");
                return http_resp(conn, false, websocketpp::http::status_code::bad_request, "⽤⼾名密码错误");
            }
            //3. 如果验证成功，给客⼾端创建session
            uint64_t uid = login_info["id"].asUInt64();
            session_ptr ssp = _sm.create_session(uid, LOGIN);
            if (ssp.get() == nullptr) 
            {
                DBG_LOG("创建会话失败");
                return http_resp(conn, false, websocketpp::http::status_code::internal_server_error , "创建会话失败");
            }
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
            //4. 设置响应头部：Set-Cookie,将sessionid通过cookie返回
            std::string cookie_ssid = "SSID=" + std::to_string(ssp->get_ssid());
            conn->append_header("Set-Cookie", cookie_ssid);
            return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
        }

        bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val) 
        {
            // Cookie: SSID=XXX; path=/;
            //1. 以 ; 作为间隔，对字符串进⾏分割，得到各个单个的cookie信息
            std::string sep = "; ";
            std::vector<std::string> cookie_arr;
            string_util::split(cookie_str, sep, cookie_arr);
            for (auto str : cookie_arr) 
            {
                //2. 对单个cookie字符串，以 = 为间隔进⾏分割，得到key和val
                std::vector<std::string> tmp_arr;
                string_util::split(str, "=", tmp_arr);
                if (tmp_arr.size() != 2) { continue; }
                if (tmp_arr[0] == key) 
                {
                    val = tmp_arr[1];
                    return true;
                }
            }
            return false;
        }

        void info(wsserver_t::connection_ptr& conn)
        {
            //用户信息获取功能请求的处理
            Json::Value err_resp;
            // 1. 获取请求信息中的Cookie，从Cookie中获取ssid
            std::string cookie_str = conn->get_request_header("Cookie");
            if (cookie_str.empty()) 
            {
                //如果没有cookie，返回错误：没有cookie信息，让客⼾端重新登录
                DBG_LOG("找不到cookie信息，请重新登录");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录");
            }
            // 1.5. 从cookie中取出ssid
            std::string ssid_str;
            bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
            if (ret == false) 
            {
                //cookie中没有ssid，返回错误：没有ssid信息，让客⼾端重新登录
                DBG_LOG("找不到ssid信息，请重新登录");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录");
            }
            // 2. 在session管理中查找对应的会话信息
            session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
            if (ssp.get() == nullptr) 
            {
                //没有找到session，则认为登录已经过期，需要重新登录
                DBG_LOG("登录过期，请重新登录");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
            }
            // 3. 从数据库中取出⽤⼾信息，进⾏序列化发送给客⼾端
            uint64_t uid = ssp->get_user();
            Json::Value user_info;
            ret = _ut.select_by_id(uid, user_info);
            if (ret == false) 
            {
                //获取⽤⼾信息失败，返回错误：找不到⽤⼾信息
                DBG_LOG("找不到⽤⼾信息，请重新登录");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到⽤⼾信息，请重新登录");
            }
            std::string body;
            json_util::serialize(user_info, body);
            std::cout << body << std::endl;
            conn->set_body(body);
            conn->append_header("Content-Type", "application/json");
            conn->set_status(websocketpp::http::status_code::ok);
            // 4. 刷新session的过期时间
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);

        }
        void wshttp_callback(websocketpp::connection_hdl hdl)
        {
            wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
            websocketpp::http::parser::request request = conn->get_request();
            std::string method = request.get_method();
            std::string uri = request.get_uri();
            std::cout << "body: " << conn->get_request_body() << std::endl;
            std::cout << "method: " << request.get_method() << std::endl;
            std::cout << "uri: " << request.get_uri() << std::endl;
            if (method == "POST" && uri == "/register") {
                return regist(conn);
            }else if (method == "POST" && uri == "/login") {
                return login(conn);
            }else if (method == "GET" && uri == "/info") {
                return info(conn);
            }else {
                return;
            }
        }
        void ws_resp(wsserver_t::connection_ptr conn, Json::Value &resp) {
            std::string body;
            json_util::serialize(resp, body);
            conn->send(body);
        }
        session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn) {
            Json::Value err_resp;
            // 1. 获取请求信息中的Cookie，从Cookie中获取ssid
            std::string cookie_str = conn->get_request_header("Cookie");
            if (cookie_str.empty()) {
                //如果没有cookie，返回错误：没有cookie信息，让客⼾端重新登录
                err_resp["optype"] = "hall_ready";
                err_resp["reason"] = "没有找到cookie信息，需要重新登录";
                err_resp["result"] = false;
                ws_resp(conn, err_resp);
                return session_ptr();
            }
            // 1.5. 从cookie中取出ssid
            std::string ssid_str;
            bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
            if (ret == false) {
                //cookie中没有ssid，返回错误：没有ssid信息，让客⼾端重新登录
                err_resp["optype"] = "hall_ready";
                err_resp["reason"] = "没有找到SSID信息，需要重新登录";
                err_resp["result"] = false;
                ws_resp(conn, err_resp);
                return session_ptr();
            }
                // 2. 在session管理中查找对应的会话信息
                session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
                if (ssp.get() == nullptr) {
                //没有找到session，则认为登录已经过期，需要重新登录
                err_resp["optype"] = "hall_ready";
                err_resp["reason"] = "没有找到session信息，需要重新登录";
                err_resp["result"] = false;
                ws_resp(conn, err_resp);
                return session_ptr();
            }
            return ssp;
        }
        void wsopen_game_hall(wsserver_t::connection_ptr conn)
        {
            //游戏⼤厅⻓连接建⽴成功
            Json::Value resp_json;
            //1. 登录验证--判断当前客⼾端是否已经成功登录
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                return;
            }
            //2. 判断当前客⼾端是否是重复登录
            if (_om.is_in_game_hall(ssp->get_user()) /*|| _om.is_in_game_room(ssp->get_user())*/) {
                resp_json["optype"] = "hall_ready";
                resp_json["reason"] = "玩家重复登录！";
                resp_json["result"] = false;
                return ws_resp(conn, resp_json);
            }
            //3. 将当前客⼾端以及连接加⼊到游戏⼤厅
            _om.enter_game_hall(ssp->get_user(), conn);
            //4. 给客⼾端响应游戏⼤厅连接建⽴成功
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = true;
            ws_resp(conn, resp_json);
            //5. 记得将session设置为永久存在
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
        }
        void wsopen_game_room(wsserver_t::connection_ptr conn) {
            Json::Value resp_json;
            //1. 获取当前客⼾端的session
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                return;
            }
            //2. 当前⽤⼾是否已经在在线⽤⼾管理的游戏房间或者游戏⼤厅中---在线⽤⼾管理
            if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user())) {
                resp_json["optype"] = "room_ready";
                resp_json["reason"] = "玩家重复登录！";
                resp_json["result"] = false;
                return ws_resp(conn, resp_json);
            }
            //3. 判断当前⽤⼾是否已经创建好了房间 --- 房间管理
            room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
            if (rp.get() == nullptr) {
                resp_json["optype"] = "room_ready";
                resp_json["reason"] = "没有找到玩家的房间信息";
                resp_json["result"] = false;
                return ws_resp(conn, resp_json);
            }
            //4. 将当前⽤⼾添加到在线⽤⼾管理的游戏房间中
            _om.enter_game_room(ssp->get_user(), conn);
            //5. 将session重新设置为永久存在
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
            //6. 回复房间准备完毕
            resp_json["optype"] = "room_ready";
            resp_json["result"] = true;
            resp_json["room_id"] = (Json::UInt64)rp->id();
            resp_json["uid"] = (Json::UInt64)ssp->get_user();
            resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
            resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
            return ws_resp(conn, resp_json);
        }
        void wsopen_callback(websocketpp::connection_hdl hdl)
        {
            //websocket长连接建立成功之后的处理函数
            wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
            websocketpp::http::parser::request request = conn->get_request();
            std::string method = request.get_method();
            std::string uri = request.get_uri();
            std::cout << "body: " << conn->get_request_body() << std::endl;
            std::cout << "method: " << request.get_method() << std::endl;
            std::cout << "uri: " << request.get_uri() << std::endl;
            if(uri == "/hall")
            {
                //建立了游戏大厅的长连接
                DBG_LOG("开始建立游戏大厅的长连接...");
                return wsopen_game_hall(conn);
            }
            else if(uri == "/room")
            {
                //建立了游戏房间的长连接
                DBG_LOG("开始建立游戏房间的长连接...");
                return wsopen_game_room(conn);
            }
            else
            {
                DBG_LOG("未知地址");
            }
        }
        void wsclose_game_hall(wsserver_t::connection_ptr conn)
        {
            //游戏⼤厅⻓连接断开的处理
            //1. 登录验证--判断当前客⼾端是否已经成功登录
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                DBG_LOG("wsclose_hall登录验证失败");
                return;
            }
            DBG_LOG("wsclose_hall登录验证成功");
            //1. 将玩家从游戏⼤厅中移除
            
            _om.exit_game_hall(ssp->get_user());
            //2. 将session恢复⽣命周期的管理，设置定时销毁
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        }
        void wsclose_game_room(wsserver_t::connection_ptr conn)
        {
            //获取会话信息，识别客⼾端
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                DBG_LOG("wsclose_room登录验证失败");
                return;
            }
            DBG_LOG("wsclose_room登录验证成功");
            //1. 将玩家从在线⽤⼾管理中移除
            std::cout << ssp->get_user() << " 已被移除在线⽤⼾管理" << std::endl;
            _om.exit_game_room(ssp->get_user());
            //2. 将session恢复⽣命周期的管理，设置定时销毁
            _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
            //3. 将玩家从游戏房间中移除，房间中所有⽤⼾退出了就会销毁房间
            _rm.remove_room_user(ssp->get_user());
        }
        void wsclose_callback( websocketpp::connection_hdl hdl)
        {
            //websocket连接断开前的处理
            wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
            websocketpp::http::parser::request request = conn->get_request();
            std::string method = request.get_method();
            std::string uri = request.get_uri();
            std::cout << "body: " << conn->get_request_body() << std::endl;
            std::cout << "method: " << request.get_method() << std::endl;
            std::cout << "uri: " << request.get_uri() << std::endl;
            if(uri == "/hall")
            {
                //建立了游戏大厅的长连接
                DBG_LOG("wsclose建立了游戏大厅的长连接...");
                return wsclose_game_hall(conn);
            }
            else if(uri == "/room")
            {
                //建立了游戏房间的长连接
                DBG_LOG("wsclose建立了游戏房间的长连接...");
                return wsclose_game_room(conn)
;            }
        }
        void wsmessage_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
        {
            Json::Value resp_json;
            std::string resp_body;
            //1. ⾝份验证，当前客⼾端到底是哪个玩家
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                DBG_LOG("wsmessage登录验证失败");
                return;
            }
            DBG_LOG("wsmessage登录验证成功");
            //2. 获取请求信息
            std::string req_body = msg->get_payload();
            Json::Value req_json;
            bool ret = json_util::unserialize(req_body, req_json);
            if (ret == false) {
                resp_json["result"] = false;
                resp_json["reason"] = "请求信息解析失败";
                return ws_resp(conn, resp_json);
            }
            //3. 对于请求进⾏处理：
            if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start"){
            // 开始对战匹配：通过匹配模块，将⽤⼾添加到匹配队列中
                _mm.add(ssp->get_user());
                resp_json["optype"] = "match_start";
                resp_json["result"] = true;
                return ws_resp(conn, resp_json);
            }
            else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop") {
                // 停⽌对战匹配：通过匹配模块，将⽤⼾从匹配队列中移除
                _mm.del(ssp->get_user());
                resp_json["optype"] = "match_stop";
                resp_json["result"] = true;
                return ws_resp(conn, resp_json);
            }
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求类型未知";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        void wsmessage_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
        {
            Json::Value resp_json;
            //1. 获取客⼾端session，识别客⼾端⾝份
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                DBG_LOG("房间-没有找到会话信息");
                return;
            }
            //2. 获取客⼾端房间信息
            room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
            if (rp.get() == nullptr) {
                resp_json["optype"] = "unknow";
                resp_json["reason"] = "没有找到玩家的房间信息";
                resp_json["result"] = false;
                DBG_LOG("房间-没有找到玩家房间信息");
                return ws_resp(conn, resp_json);
            }
            //3. 对消息进⾏反序列化
            Json::Value req_json;
            std::string req_body = msg->get_payload();
            bool ret = json_util::unserialize(req_body, req_json);
            if (ret == false) {
                resp_json["optype"] = "unknow";
                resp_json["reason"] = "请求解析失败";
                resp_json["result"] = false;
                DBG_LOG("房间-反序列化请求失败");
                return ws_resp(conn, resp_json);
            }
            DBG_LOG("房间：收到房间请求，开始处理....");
            //4. 通过房间模块进⾏消息请求的处理
            return rp->handle_request(req_json);
        }
        void wsmessage_callback( websocketpp::connection_hdl hdl, wsserver_t::message_ptr message)
        {
            //websocket长连接通信处理
            wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
            websocketpp::http::parser::request request = conn->get_request();
            std::string method = request.get_method();
            std::string uri = request.get_uri();
            std::cout << "body: " << conn->get_request_body() << std::endl;
            std::cout << "method: " << request.get_method() << std::endl;
            std::cout << "uri: " << request.get_uri() << std::endl;
            if(uri == "/hall")
            {
                //建立了游戏大厅的长连接
                DBG_LOG("wsmessage建立游戏大厅的长连接");
                return wsmessage_game_hall(conn, message);
            }
            else if(uri == "/room")
            {
                //建立了游戏房间的长连接
                DBG_LOG("wsmessage建立游戏房间的长连接");
                return wsmessage_game_room(conn, message);
;            }
        }
    public:
        //进行成员初始化，以及服务器会第哦啊函数的设置
        gobang_server(const std::string &host,
                    const std::string &user,
                    const std::string &pass,
                    const std::string &db,
                    uint16_t port = 3306)
                    :_ut(host, user, pass, db, port),
                    _rm(&_ut, &_om),
                    _mm(&_rm, &_ut, &_om),
                    _sm(&_wssrv)
        {
            //2.设置日志输出等级
            _wssrv.set_access_channels(websocketpp::log::alevel::none);
            //3.初始化asio框架中的调度器
            _wssrv.init_asio();
            _wssrv.set_reuse_addr(true);
            //4.设置业务处理回调函数
            _wssrv.set_http_handler(std::bind(&gobang_server::wshttp_callback, this, std::placeholders::_1));
            _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
            _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
            _wssrv.set_message_handler(std::bind(&gobang_server::wsmessage_callback, this, std::placeholders::_1, std::placeholders::_2));
        }
        ~gobang_server()
        {}
        //启动服务器
        void start(int port)
        {
            //5.设置服务器监听端口
            _wssrv.listen(port);
            //6.开始获取新建连接
            _wssrv.start_accept();
            //7.启动服务器
            _wssrv.run();
        }
    private:
        user_table _ut;
        matcher _mm;
        online_manager _om;
        room_manager _rm;
        session_manager _sm;
        wsserver_t _wssrv;
};

#endif